// Decompiled by DJ v3.7.7.81 Copyright 2004 Atanas Neshkov  Date: 2007-9-15 18:53:57

// Source File Name:   jh.java

package com.zelix;

import java.io.*;
import java.util.*;
import java.util.zip.*;

//            rb, hc, nc, qc,
//            rc, tb, nh, lt, 
//            mt, yx, zx, ay, 
//            by, r0, s0, t0, 
//            u0, zr, v0, w0, 
//            bs, px, wu, ly, 
//            w6, my, yg

final class jh {

    private static final String a = System.getProperty(z(z("CILd\rVEP`QDTOs")));
    private mt b[];
    File c;
    private int d;
    bs e;
    nh f;
    private wu g;
    hc h[];
    private HashSet t;
    HashMap i;
    Vector j;
    Hashtable k;
    private Hashtable l;
    Hashtable m;
    ly n;
    ly o;
    private ly p;
    private my q;
    private yg r;
    yx s;
    private static String z[];

    jh(mt amt[], File file, bs bs1, nh nh1) {
        j = new Vector();
        k = new Hashtable();
        l = new Hashtable();
        m = new Hashtable();
        b = amt;
        c = file;
        e = bs1;
        f = nh1;
        e();
    }

    jh(mt amt[], hc ahc[], HashSet hashset, HashMap hashmap, ly ly1, ly ly2, ly ly3,
       my my, yg yg, File file, int i1, bs bs1, nh nh1, wu wu1) {
        j = new Vector();
        k = new Hashtable();
        l = new Hashtable();
        m = new Hashtable();
        b = amt;
        h = ahc;
        t = hashset;
        i = hashmap;
        n = ly1;
        o = ly2;
        p = ly3;
        q = my;
        r = yg;
        c = file;
        d = i1;
        e = bs1;
        f = nh1;
        g = wu1;
        try {
            c();
            HashMap hashmap1 = new HashMap();
            Hashtable hashtable = a(hashmap1);
            s = new yx(ly1, new ly(hashtable));
            g();
            b(hashmap1);
            b();
            h();
        }
        finally {
            a();
        }
        f();
    }

    private void a() {
        Enumeration enumeration;
        enumeration = k.elements();
        while (enumeration.hasMoreElements()) {
            ZipFile zipfile = (ZipFile) enumeration.nextElement();
            String s1 = zipfile.getName();
            try {
                zipfile.close();
            }
            catch (IOException ioexception) {
                f.e(z[42] + s1 + z[25] + ioexception.getMessage());
            }
        }
        Enumeration enumeration1 = m.keys();
        while (enumeration1.hasMoreElements()) {
            hc hc1 = (hc) enumeration1.nextElement();
            if (hc1.j()) {
                ZipOutputStream zipoutputstream = (ZipOutputStream) m.get(hc1);
                try {
                    zipoutputstream.close();
                }
                catch (IOException ioexception1) {
                    f.e(z[41] + hc1.f() + z[25] + ioexception1.getMessage());
                }
            }
        }
    }

    private void b() {
        for (Enumeration enumeration = k.keys(); enumeration.hasMoreElements();) {
            hc hc1 = (hc) enumeration.nextElement();
            String s1 = hc1.f();
            ZipFile zipfile = (ZipFile) k.get(hc1);
            ZipOutputStream zipoutputstream = (ZipOutputStream) m.get(hc1);
            if (zipoutputstream != null) {
                Enumeration enumeration1 = zipfile.entries();
                HashSet hashset = new HashSet();
                while (enumeration1.hasMoreElements()) {
                    ZipEntry zipentry = (ZipEntry) enumeration1.nextElement();
                    String s2 = zipentry.getName();
                    boolean flag = d == 1 || d == 3 && zipentry.getMethod() == 8;
                    if (t != null && t.contains(hc1))
                        try {
                            InputStream inputstream = null;
                            try {
                                inputstream = zipfile.getInputStream(zipentry);
                                if (inputstream != null) {
                                    rc rc1 = new rc(zipoutputstream, s2, flag, inputstream, (int) zipentry.getSize());
                                    rc1.b();
                                } else {
                                    f.e(z[31] + s2 + z[21] + s1 + z[29]);
                                }
                            }
                            finally {
                                if (inputstream != null)
                                    try {
                                        inputstream.close();
                                    }
                                    catch (IOException _ex) {
                                    }
                            }
                        }
                        catch (IOException ioexception) {
                            e.b(z[18], z[19] + s2 + z[21] + s1 + z[0] + ioexception.getMessage());
                        }
                    else if (!s2.endsWith(z[38]) && !hc.b(s2)) {
                        String s3 = s2.toUpperCase();
                        String s4 = s2.toLowerCase();
                        g.a(z[11] + s2);
                        if (zipentry.isDirectory() || !s3.equals(z[7]))
                            if (!zipentry.isDirectory() && s3.startsWith(z[33].toUpperCase()) && s2.length() > zx.a)
                                try {
                                    zx zx1 = new zx(zipfile, zipentry);
                                    zx1.a(zipoutputstream, o, flag);
                                }
                                catch (IOException ioexception1) {
                                    e.b(z[18], z[36] + s1 + z[25] + ioexception1);
                                }
                            else if (!zipentry.isDirectory() && s2.equalsIgnoreCase(z[30]))
                                try {
                                    t0 t0_1 = new t0(s2, o, q, s, r);
                                    new zr(zipfile, zipentry, zipoutputstream, o, q, s, r, t0_1, flag);
                                }
                                catch (rb rb1) {
                                    e.b(z[18], z[8] + s1 + z[25] + rb1.getMessage());
                                }
                                catch (IOException ioexception2) {
                                    e.b(z[18], z[4] + s1 + z[25] + ioexception2);
                                }
                            else if (!zipentry.isDirectory() && s2.equalsIgnoreCase(z[37]))
                                try {
                                    r0 r0_1 = new r0(s2, o, q, s, r);
                                    new zr(zipfile, zipentry, zipoutputstream, o, q, s, r, r0_1, flag);
                                }
                                catch (rb rb2) {
                                    e.b(z[18], z[2] + s2 + z[34] + s1 + z[25] + rb2.getMessage());
                                }
                                catch (IOException ioexception3) {
                                    e.b(z[18], z[5] + s2 + z[34] + s1 + z[25] + ioexception3);
                                }
                            else if (!zipentry.isDirectory() && s2.equalsIgnoreCase(z[35]))
                                try {
                                    s0 s0_1 = new s0(s2, o, q, s, r);
                                    new zr(zipfile, zipentry, zipoutputstream, o, q, s, r, s0_1, flag);
                                }
                                catch (rb rb3) {
                                    e.b(z[18], z[26] + s2 + z[34] + s1 + z[25] + rb3.getMessage());
                                }
                                catch (IOException ioexception4) {
                                    e.b(z[18], z[20] + s2 + z[34] + s1 + z[25] + ioexception4);
                                }
                            else
                            if (!zipentry.isDirectory() && s3.startsWith(z[28]) && (s3.endsWith(z[32]) || s3.endsWith(z[15]) || s3.endsWith(z[6]) || s3.endsWith(z[14]) || s3.endsWith(z[3]))) {
                                if (s3.endsWith(z[15]))
                                    f.e(z[1] + s1 + z[10]);
                            } else if (!zipentry.isDirectory() && s2.equalsIgnoreCase(z[22]))
                                try {
                                    w0 w0_1 = new w0(s2, o, q, s, r);
                                    new zr(zipfile, zipentry, zipoutputstream, o, q, s, r, w0_1, flag);
                                }
                                catch (rb rb4) {
                                    e.b(z[18], z[24] + s2 + z[34] + s1 + z[25] + rb4.getMessage());
                                }
                                catch (IOException ioexception5) {
                                    e.b(z[18], z[17] + s2 + z[34] + s1 + z[25] + ioexception5);
                                }
                            else if (!zipentry.isDirectory() && s4.endsWith(z[16]))
                                try {
                                    u0 u0_1 = new u0(s2, o, q, s, r);
                                    new zr(zipfile, zipentry, zipoutputstream, o, q, s, r, u0_1, flag);
                                }
                                catch (rb rb5) {
                                    e.b(z[18], z[23] + s2 + z[34] + s1 + z[25] + rb5.getMessage());
                                }
                                catch (IOException ioexception6) {
                                    e.b(z[18], z[12] + s2 + z[34] + s1 + z[25] + ioexception6);
                                }
                            else if (!zipentry.isDirectory() && s4.endsWith(z[27])) {
                                try {
                                    v0 v0_1 = new v0(s2, o, q, s, r);
                                    new zr(zipfile, zipentry, zipoutputstream, o, q, s, r, v0_1, flag);
                                }
                                catch (rb rb6) {
                                    e.b(z[18], z[9] + s2 + z[34] + s1 + z[25] + rb6.getMessage());
                                }
                                catch (IOException ioexception7) {
                                    e.b(z[18], z[13] + s2 + z[34] + s1 + z[25] + ioexception7);
                                }
                            } else {
                                String s5 = s.c(s2);
                                if (!zipentry.isDirectory() || s5.length() > 0 && hashset.add(s5))
                                    try {
                                        InputStream inputstream1 = null;
                                        try {
                                            inputstream1 = zipfile.getInputStream(zipentry);
                                            if (inputstream1 != null) {
                                                rc rc2 = new rc(zipoutputstream, s5, flag, inputstream1, (int) zipentry.getSize());
                                                rc2.b();
                                            } else {
                                                f.e(z[31] + s2 + z[21] + s1 + z[29]);
                                            }
                                        }
                                        finally {
                                            if (inputstream1 != null)
                                                try {
                                                    inputstream1.close();
                                                }
                                                catch (IOException _ex) {
                                                }
                                        }
                                    }
                                    catch (IOException ioexception8) {
                                        e.b(z[18], z[19] + s2 + z[21] + s1 + z[0] + ioexception8.getMessage());
                                    }
                            }
                        g.a(" ");
                    }
                }
            }
        }

    }

    private Hashtable a(HashMap hashmap) {
        Hashtable hashtable;
        int i1;
        hashtable = new Hashtable();
        for (i1 = 0; i1 < b.length; i1++) {
            Enumeration enumeration = b[i1].q();
            while (enumeration.hasMoreElements()) {
                nc nc1 = (nc) enumeration.nextElement();
                if (!nc1.f())
                    a(nc1, b[i1], hashtable, hashmap);
            }
        }
        return hashtable;
    }

    private void a(nc nc1, mt mt1, Hashtable hashtable, HashMap hashmap) {
        String s4;
        String s1 = nc1.d();
        s1 = s1.substring(0, s1.lastIndexOf(z[38]));
        String s2 = mt1.j();
        String s3 = (String) px.a(s2, p);
        int i1 = s1.lastIndexOf(s3);
        if (i1 > 0) {
            String s5 = s1.substring(0, i1);
            s4 = s5 + s2 + z[38];
            if (s5.length() > 1) {
                if (s5.charAt(0) == '/')
                    s5 = s5.substring(1);
                hashtable.put(s5, s5);
            }
        } else
            s4 = s2 + z[38];
        Object obj = hashmap.put(nc1, s4);
    }

    void c() {
        int i1;
        for (i1 = 0; i1 < h.length; i1++) {
            if (h[i1].j())
                j.addElement(h[i1]);
            String s1 = h[i1].b();
            try {
                w6 w6_1 = new w6(s1);
                k.put(h[i1], w6_1);
            }
            catch (IOException ioexception) {
                f.e(z[54] + s1 + z[52] + c.getAbsolutePath() + z[25] + ioexception.getMessage());
            }
        }
        Enumeration enumeration = k.keys();
        while (enumeration.hasMoreElements()) {
            hc hc1;
            File file;
            hc1 = (hc) enumeration.nextElement();
            if (hc1.j()) {
                String s2 = hc1.f();
                String s3 = c.getAbsolutePath() + a + s2.substring(s2.lastIndexOf(a) + 1);
                file = new File(s3);
                l.put(hc1, file);
                if (file.exists()) {
                    try {
                        String s4 = s3 + z[47];
                        File file1 = new File(s4);
                        if (file1.exists())
                            file1.delete();
                        file.renameTo(file1);
                        f.e(z[1] + s3 + z[49] + c.getAbsolutePath() + z[53] + s4 + z[50]);
                    }
                    catch (Exception exception) {
                        e.b(z[18], z[55] + s3 + z[25] + exception.getMessage());
                    }
                }
            } else {
                try {
                    file = qc.a();
                    l.put(hc1, file);
                }
                catch (IOException ioexception1) {
                    e.c(z[18], z[48] + qc.a + z[25] + ioexception1);
                    return;
                }
            }
            try {
                ZipOutputStream zipoutputstream = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(file), 2048));
                m.put(hc1, zipoutputstream);
            }
            catch (IOException ioexception2) {
                e.b(z[18], z[51] + file.getAbsolutePath() + z[25] + ioexception2.getMessage());
            }
        }
    }

    private final void e() {
        int i1;
        for (i1 = 0; i1 < b.length; i1++) {
            a(b[i1]);
        }
    }

    private final void a(mt mt1) {
        DataOutputStream dataoutputstream;
        String s1;
        String s2;
        StringTokenizer stringtokenizer;
        StringBuffer stringbuffer;
        dataoutputstream = null;
        s1 = mt1.j();
        s2 = s1.substring(0, s1.lastIndexOf('/') + 1);
        stringtokenizer = new StringTokenizer(s2, "/");
        stringbuffer = new StringBuffer();
        while (stringtokenizer.hasMoreTokens()) {
            stringbuffer.append(stringtokenizer.nextToken());
            String s3 = c.getAbsolutePath() + a + stringbuffer.toString();
            File file = new File(s3);
            if (!file.exists())
                file.mkdirs();
            stringbuffer.append(stringtokenizer.hasMoreElements() ? a : "");
        }
        String s4 = s1.substring(s1.lastIndexOf('/') + 1);
        String s5 = c.getAbsolutePath() + (s2.length() <= 0 ? "" : a) + stringbuffer.toString();
        s4 = s5 + a + s4 + z[38];
        try {
            FileOutputStream fileoutputstream = new FileOutputStream(s4);
            dataoutputstream = new DataOutputStream(new BufferedOutputStream(fileoutputstream, 2048));
            mt1.a(dataoutputstream, f);
        }
        catch (IOException ioexception) {
            e.b(z[18], ioexception.getMessage());
        }
        catch (tb tb1) {
            e.b(z[44], tb1.getMessage());
        }
        finally {
            if (dataoutputstream != null)
                try {
                    dataoutputstream.close();
                }
                catch (IOException _ex) {
                }
        }
    }

    private void a(nc nc1, mt mt1, HashMap hashmap, ZipOutputStream zipoutputstream, boolean flag) {
        String s1 = (String) hashmap.get(nc1);
        try {
            rc rc1 = new rc(zipoutputstream, s1, flag);
            DataOutputStream dataoutputstream = new DataOutputStream(rc1.a());
            try {
                mt1.a(dataoutputstream, f);
                dataoutputstream.flush();
                rc1.b();
            }
            catch (tb tb1) {
                e.b(z[44], tb1.getMessage());
            }
        }
        catch (IOException ioexception) {
            e.b(z[18], z[45] + mt1.l() + z[46] + s1 + z[25] + ioexception.getMessage());
        }
    }

    private void b(HashMap hashmap) {
        int i1;
        for (i1 = 0; i1 < b.length; i1++) {
            Enumeration enumeration = b[i1].q();
            while (enumeration.hasMoreElements()) {
                nc nc1 = (nc) enumeration.nextElement();
                if (nc1.f()) {
                    a(b[i1]);
                } else {
                    hc hc1 = nc1.e();
                    ZipFile zipfile = (ZipFile) k.get(hc1);
                    ZipEntry zipentry = zipfile.getEntry(nc1.d());
                    ZipOutputStream zipoutputstream = (ZipOutputStream) m.get(hc1);
                    if (zipoutputstream != null) {
                        boolean flag = d == 1 || d == 3 && zipentry.getMethod() == 8;
                        a(nc1, b[i1], hashmap, zipoutputstream, flag);
                    } else {
                        a(b[i1]);
                    }
                }
            }
        }
    }

    private void f() {
        if (i != null) {
            Iterator iterator = i.entrySet().iterator();
            while (iterator.hasNext()) {
                java.util.Map.Entry entry = (java.util.Map.Entry) iterator.next();
                by by1 = (by) entry.getKey();
                hc hc1 = (hc) entry.getValue();
                Object obj = null;
                if (hc1 != null) {
                    File file = (File) l.get(hc1);
                    if (file != null)
                        by1.a(file.length());
                }
                File file1 = new File(c, by1.b());
                try {
                    by1.a(file1, n, o, s);
                }
                catch (rb rb1) {
                    e.b(z[40], z[39] + rb1.getMessage());
                }
            }
        }
    }

    private void g() {
        Enumeration enumeration;
        enumeration = k.keys();
        while (enumeration.hasMoreElements()) {
            hc hc1 = (hc) enumeration.nextElement();
            if (t == null || !t.contains(hc1)) {
                ZipFile zipfile = (ZipFile) k.get(hc1);
                String s1 = hc1.f();
                ZipOutputStream zipoutputstream = (ZipOutputStream) m.get(hc1);
                ay ay1 = hc1.a();
                if (zipoutputstream != null && ay1 != null) {
                    boolean flag = d == 1 || d == 3 && ay1.c();
                    try {
                        ay1.a(zipoutputstream, n, o, s, flag);
                    }
                    catch (IOException ioexception) {
                        e.b(z[18], z[43] + hc1.f() + z[25] + ioexception);
                    }
                }
            }
        }
    }

    private void h() {
        int i1;
        g.a(z[56]);
        for (i1 = 0; i1 < j.size(); i1++) {
            hc hc1;
            Enumeration enumeration;
            hc1 = (hc) j.elementAt(i1);
            enumeration = hc1.a();
            while (enumeration.hasMoreElements()) {
                hc hc2 = (hc) enumeration.nextElement();
                a(hc2, hc1);
            }
        }
        g.a(" ");
    }

    private void a(hc hc1, hc hc2) {
        Enumeration enumeration;
        enumeration = hc1.a();
        while (enumeration.hasMoreElements()) {
            hc hc3 = (hc) enumeration.nextElement();
            a(hc3, hc1);
        }
        ZipOutputStream zipoutputstream = (ZipOutputStream) m.get(hc2);
        ZipOutputStream zipoutputstream1 = (ZipOutputStream) m.get(hc1);
        BufferedInputStream bufferedinputstream = null;
        try {
            zipoutputstream1.close();
            File file = (File) l.get(hc1);
            ZipFile zipfile = (ZipFile) k.get(hc2);
            ZipEntry zipentry = zipfile.getEntry(hc1.f());
            boolean flag = d == 1 || d == 3 && zipentry.getMethod() == 8;
            rc rc1 = new rc(zipoutputstream, hc1.f(), flag, file);
            rc1.b();
        }
        catch (IOException ioexception) {
            e.b(z[18], z[58] + hc1.f() + z[57] + hc2.f() + z[25] + ioexception);
        }
        finally {
            if (bufferedinputstream != null)
                try {
                    bufferedinputstream.close();
                }
                catch (IOException ioexception1) {
                }
        }
    }

    private static char[] z(String str) {
        char ac[] = str.toCharArray();
        int clen = ac.length;
        if (clen >= 2)
            return ac;
        ac[0] ^= 0x23;
        return ac;
    }

    private static String z(char[] chs) {
        for (int i = 0; i < chs.length; i++) {
            byte key = 0;
            switch (i % 5) {
                case 0:
                    key = 0x25;
                    break;
                case 1:
                    key = 32;
                    break;
                case 2:
                    key = 32;
                    break;
                case 3:
                    key = 1;
                    break;
                default:
                    key = 35;
                    break;
            }
            chs[i] ^= key;
        }
        return new String(chs).intern();
    }

    static {
        String as[] = new String[59];
        as[0] = z(z("\002\000Tn\003KEW!BWCHhU@\000\032!"));
        as[1] = z(z("cILd\003\002"));
        as[2] = z(z("lNV`OLD\000`SULIbBQIOo\r]ML!ELLE!\004"));
        as[3] = z(z("\013pgQ"));
        as[4] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003@JB,IDR\016yNI\000Io\003\002"));
        as[5] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003DPPmJFAThLK\016XlO\005FImF\005\007"));
        as[6] = z(z("\013ds@"));
        as[7] = z(z("het@\016lnf.ndniGfvt\016Le"));
        as[8] = z(z("lNV`OLD\000dIG\rJ`Q\013XMm\003LN\000&"));
        as[9] = z(z("lNV`OLD\000Uoa\000xLo\005FImF\005\007"));
        as[10] = z(z("\002\000AqS@ARr\003QO\000iBSE\000cF@N\000rJBNEe\r\005sIfMDTUsF\005DAuB\005RElLSED/\003|OU!NPST!Q@\rShDK\000aGw`r\000nACUSbBQIOo\r"));
        as[11] = z(z("vAVhMB\0"));
        as[12] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003}ml!ELLE!\004"));
        as[13] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003qld!{hl\000gJIE\000&"));
        as[14] = z(z("\013rs@"));
        as[15] = z(z("\013sf"));
        as[16] = z(z("\013XMm"));
        as[17] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003REB/[HL\000gJIE\000&"));
        as[18] = z(z("cilD\003`rrNq\037"));
        as[19] = z(z("fOUmGK\007T!@JPY!\004"));
        as[20] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003DPPmJFAThLK\rCmJ@NT/[HL\000gJIE\000&"));
        as[21] = z(z("\002\000FsLH\000\007"));
        as[22] = z(z("reb,jkf\017vFG\016XlO"));
        as[23] = z(z("lNV`OLD\000Yni\000FhO@\000\007"));
        as[24] = z(z("lNV`OLD\000vFG\016XlO\005FImF\005\007"));
        as[25] = z(z("\002\000\032!"));
        as[26] = z(z("lNV`OLD\000`SULIbBQIOo\016FLIdMQ\016XlO\005FImF\005\007"));
        as[27] = z(z("\013TLe"));
        as[28] = z(z("het@\016lnf."));
        as[29] = z(z("\002\000Tn\003KEW!BWCHhU@\000Bd@DUSd\003QHE!FKTRx\003DPPdBWS\000uL\005BE!@JRRtSQ"));
        as[30] = z(z("het@\016lnf.FOB\rkBW\016XlO"));
        as[31] = z(z("cILd\003`RRnQ\037\000cnVIDN&W\005COqZ\005\007"));
        as[32] = z(z("lndD{\013liRw"));
        as[33] = z(z("het@\016lnf.P@RVh@@S\017"));
        as[34] = z(z("\002\000Io\003\002"));
        as[35] = z(z("het@\016lnf.BUPLh@DTInM\bCLhFKT\016yNI"));
        as[36] = z(z("`RRnQ\005RE`GLNG!LW\000WsJQINf\003VERwJFE\000qQJVIeFW\000Io\003\002"));
        as[37] = z(z("het@\016lnf.BUPLh@DTInM\013XMm"));
        as[38] = z(z("\013CL`PV"));
        as[39] = z(z("oad!ELLE!TWITd\003@RRnQ\005\032\0"));
        as[40] = z(z("oad!elle!fwroS\031"));
        as[41] = z(z("cilD\003`rrNq\005\b\022(\003\002"));
        as[42] = z(z("cilD\003`rrNq\005\b\021(\003\002"));
        as[43] = z(z("fOUmGK\007T!TWITd\003hanHe`st/nc\000Tn\003\002"));
        as[44] = z(z("`rrNq\037"));
        as[45] = z(z("fOUmGK\007T!PDVE!\004"));
        as[46] = z(z("\002\000Tn\003KEW!BWCHhU@\000\032!\004"));
        as[47] = z(z("\013baBhpp"));
        as[48] = z(z("fOUmG\005NOu\003FRE`W@\000TdNUOR`Q\\\000FhO@\000Io\003\002"));
        as[49] = z(z("\002\000AmQ@ADx\003@XIrWV\000Io\003\002"));
        as[50] = z(z("\002\016"));
        as[51] = z(z("fOUmGK\007T!@WEAuF\005\007"));
        as[52] = z(z("\002\016\000HWV\000CmBVSEr\003RILm\003GE\000rBSED!WJ\000\007"));
        as[53] = z(z("\002\016\000SFKAMhMB\000Tn\003\002"));
        as[54] = z(z("fOUmGK\007T!LUEN!\004"));
        as[55] = z(z("fOUmGK\007T!ADCK!VU\000AoG\005REbQ@ATd\003\002"));
        as[56] = z(z("rRIuJKG\000oFVTEe\003DRCiJSE\000gJIES"));
        as[57] = z(z("\005TO!\004"));
        as[58] = z(z("fOUmGK\007T!TWITd\003"));
        z = as;
    }
}